package com.ruoyi.system.service.impl;

import com.ruoyi.common.config.RuoYiConfig;
import com.ruoyi.common.core.text.Convert;
import com.ruoyi.system.domain.*;
import com.ruoyi.system.mapper.*;
import com.ruoyi.system.service.*;
import com.ruoyi.system.tools.BooleanMessage;
import org.apache.ibatis.annotations.Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.validation.constraints.Max;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAdjusters;
import java.util.*;

/**
 * 【请填写功能名称】Service业务层处理
 *
 * @author ruoyi
 * @date 2024-06-19
 */
@Service
public class JisuanServiceImpl implements IJisuanService
{

    @Autowired
    private IJingfeiJingfeipiciService jingfeiJingfeipiciService;

    @Autowired
    private RenwuMapper renwuMapper;

    @Autowired
    private IDeptService deptService;


    @Autowired
    private JingfeiZhuanjiaMonthMapper jingfeiZhuanjiaMonthMapper;

    @Autowired
    private JingfeiZhuanjiaMapper jingfeiZhuanjiaMapper;

    @Autowired
    private IJingfeiJingfeipiciyueService jingfeiJingfeipiciyueService;

    @Autowired
    private JingfeiDeptMonthMapper  jingfeiDeptMonthMapper;

    @Autowired
    private JingfeiDeptMapper jingfeiDeptMapper;

    @Autowired
    private ZhuanjiabiandongshenbaoMapper zhuanjiabiandongshenbaoMapper;

    @Autowired
    private JingfeiDanweijingfeiServiceImpl jingfeiDanweijingfeiService;

    @Autowired
    private JingfeiZhiliuMapper jingfeiZhiliuMapper;

    @Autowired
    private JingfeiTuikuanjiluMapper jingfeiTuikuanjiluMapper;

    @Autowired
    private TuikuanZhiliujiluMapper tuikuanZhiliujiluMapper;

    @Autowired
    private JingfeiJingfeipiciyueMapper jingfeiJingfeipiciyueMapper;

    @Override
    @Transactional
    public BooleanMessage tuikuanshoukuan(JingfeiTuikuanjilu mm退款记录,String ppDeptId ) {
        // 退款记录改为收款
        if(mm退款记录.getIsshoudao()!=0){
            return BooleanMessage.getErrorMessage("当前记录已收款 请勿重复操作");
        }
        mm退款记录.setIsshoudao(1l);
        mm退款记录.setShoudaoshijian(new Date());
        jingfeiTuikuanjiluMapper.updateJingfeiTuikuanjilu(mm退款记录);

        // 查询本记录下的所有滞留id
        List<String> mm变动滞留id = new ArrayList<>();
        TuikuanZhiliujilu mm查询条件 = new TuikuanZhiliujilu();
        mm查询条件.setTuikuanjiluid(mm退款记录.getId());
        mm查询条件.setStatus(1);
        List<TuikuanZhiliujilu> mm退款滞留 = tuikuanZhiliujiluMapper.selectTuikuanZhiliujiluList(mm查询条件);
        for (TuikuanZhiliujilu mmone: mm退款滞留) {
            mm变动滞留id.add(mmone.getZhiliuid());
        }
        if(mm变动滞留id.size()>0){
            jingfeiZhiliuMapper.updateShoukuanByIds(mm变动滞留id);
        }
        // 更新单位经费
        JingfeiDanweijingfei mm当前 = jingfeiDanweijingfeiService.selectJingfeiDanweijingfeiByDeptid(ppDeptId);
        // 查询最新的滞留总额
        Object mm滞留金额 = jingfeiZhiliuMapper.countZLByDeptId(ppDeptId);
        long 滞留金额 = mm滞留金额 == null ? 0 : Long.parseLong(mm滞留金额.toString().replace(".0",""));

        if(滞留金额!=mm当前.getJieyujingfei()+mm退款记录.getZongjine()){ // 如果新加入的 退款总金额 和原本旧的总经费 与 计算出来的不一致
            throw new RuntimeException("退款经费计算有误！");
        }
        mm当前.setZongjingfei(mm当前.getZongjingfei()+mm退款记录.getZongjine());
        mm当前.setJieyujingfei(滞留金额);
        jingfeiDanweijingfeiService.updateJingfeiDanweijingfei(mm当前);

        return BooleanMessage.getSuccessMessage("发放成功");
    }


    @Override
    public List<Map<String,Object>> findTKJLByDeptIdAndZhuangtai(String tuikuandeptid, String shoukuandeptid, int isshoudao) {
        return jingfeiZhiliuMapper.findTKJLByDeptIdAndZhuangtai(tuikuandeptid,shoukuandeptid,isshoudao);
    }


    @Override
    public List<Map<String,Object>> findZLByDeptId(String ppDeptId) {
        return jingfeiZhiliuMapper.findZLByDeptId(ppDeptId);
    }


    @Override
    @Transactional
    public BooleanMessage tuikuan(List<String> ppIds,String ppDeptId,String yuanyin) {
        Dept mm当前单位 = deptService.selectDeptByDeptid(ppDeptId); // 查询当前单位
        List<Map<String,Object>> mm滞留all = jingfeiZhiliuMapper.findByIdsAndDeptId(ppIds,ppDeptId);
        JingfeiTuikuanjilu mm退款记录 = new JingfeiTuikuanjilu();
        List<TuikuanZhiliujilu> mm退款关系集合 = new ArrayList<>();
        List<String> mm变动滞留id = new ArrayList<>();
        String 退款id = UUID.randomUUID().toString();
        long mm退款总额 = 0;
        for (Map<String,Object> mmOne:mm滞留all) {
            String id = mmOne.get("id")==null?"":mmOne.get("id").toString();
            String 金额 = mmOne.get("jine") == null ? "0" : mmOne.get("jine").toString();
            long 具体金额 = Long.valueOf(金额.replace(".0",""));
            mm退款总额 = mm退款总额 + 具体金额;
            TuikuanZhiliujilu mm关系 =  new TuikuanZhiliujilu();
            mm关系.setTuikuanjiluid(退款id);
            mm关系.setZhiliuid(id);
            mm关系.setStatus(1);
            mm退款关系集合.add(mm关系);
            mm变动滞留id.add(id);
        }

        // 创建一个新的退款批次
        mm退款记录.setId(退款id);
        mm退款记录.setShoukuandeptid(mm当前单位.getParentid());
        mm退款记录.setTuikuandeptid(ppDeptId);  // 本单位退款
        mm退款记录.setZongjine(mm退款总额);
        mm退款记录.setTuituanyuanyin(yuanyin);
        mm退款记录.setTuikuanshijian(new Date());
        mm退款记录.setIsshoudao(0l);

        if(mm变动滞留id.size()>0){ //将所有的滞留变成新的单位和未接受状态
            jingfeiZhiliuMapper.updateJingfeiZhiliuByIds(mm变动滞留id,mm当前单位.getParentid());
        }
        // 添加退款记录
        jingfeiTuikuanjiluMapper.insertJingfeiTuikuanjilu(mm退款记录);
        // 添加关系表
        tuikuanZhiliujiluMapper.insertBatch(mm退款关系集合);

        // 更新单位经费
        JingfeiDanweijingfei mm当前 = jingfeiDanweijingfeiService.selectJingfeiDanweijingfeiByDeptid(ppDeptId);
        // 查询最新的滞留总额
        Object mm滞留金额 = jingfeiZhiliuMapper.countZLByDeptId(ppDeptId);
        long 滞留金额 = mm滞留金额 == null ? 0 : Long.parseLong(mm滞留金额.toString().replace(".0",""));
        mm当前.setZongjingfei(mm当前.getZongjingfei()-mm退款总额);
        mm当前.setJieyujingfei(滞留金额);
        jingfeiDanweijingfeiService.updateJingfeiDanweijingfei(mm当前);

        return BooleanMessage.getSuccessMessage("发放成功");
    }

    @Override
    @Transactional
    public BooleanMessage shoukuan(JingfeiDept pp经费单位) { //传值批次id

        pp经费单位.setIsshoukuan(1l);
        pp经费单位.setShoukuanshijian(new Date());
        long 添加 = pp经费单位.getFafangjine();
        Dept mm本单位 = deptService.selectDeptByDeptid(pp经费单位.getDeptid());
        JingfeiDanweijingfei mmone = jingfeiDanweijingfeiService.selectJingfeiDanweijingfeiByDeptid(pp经费单位.getDeptid());
        JingfeiDanweijingfei mm上级单位经费 = jingfeiDanweijingfeiService.selectJingfeiDanweijingfeiByDeptid(mm本单位.getParentid());  // 上级单位的经费 用于减去代发

        if(mmone==null){
            JingfeiDanweijingfei mmadd = new JingfeiDanweijingfei();
            mmadd.setDeptid(pp经费单位.getDeptid());
            mmadd.setDeptname(deptService.selectDeptByDeptid(pp经费单位.getDeptid()).getDeptname());
            mmadd.setZongjingfei(添加);
            mmadd.setYifajingfei(0l);
            mmadd.setDaifajingfei(0l);
            mmadd.setJieyujingfei(0l);
            jingfeiDanweijingfeiService.insertJingfeiDanweijingfei(mmadd);
        }else{
            mmone.setZongjingfei(mmone.getZongjingfei()+添加);
            jingfeiDanweijingfeiService.updateJingfeiDanweijingfei(mmone);
        }
        mm上级单位经费.setDaifajingfei(mm上级单位经费.getDaifajingfei() - 添加); // 本单位收款了 上级单位的带发 同步减少
        mm上级单位经费.setZongjingfei(mm上级单位经费.getZongjingfei()-添加);
        jingfeiDanweijingfeiService.updateJingfeiDanweijingfei(mm上级单位经费);


        jingfeiDeptMapper.updateJingfeiDept(pp经费单位); // 修改原本的经费单位记录
        jingfeiDeptMonthMapper.updateQuerenByJingfeiIdAndDeptId(pp经费单位.getJingfeipiciid(),pp经费单位.getDeptid());
        // 发放专家经费
        return  BooleanMessage.getSuccessMessage("收款成功");
    }


    @Override
    @Transactional
    public BooleanMessage Deptfafang(String ppPiciId,String deptid,String[] mmdeptIds,String[] mmzhuanjiaIds) { //传值批次id
        JingfeiJingfeipici  mm批次 = jingfeiJingfeipiciService.selectJingfeiJingfeipiciByJingfeipiciid(ppPiciId);                   // 查询批次 、
//        if(mm批次.getJiezhishijian().compareTo(new Date())<0){
//            return BooleanMessage.getErrorMessage("截止时间之后才可计算和发放经费");
//        }
        //JingfeiJingfeipici  mm专家中心批次 = jingfeiJingfeipiciService.selectJingfeiJingfeipiciByJingfeipiciid(mm批次.getBeizhu1());

        // 因为存在跨区域  获取最后的专家中心变动截止时间  获取最小的专家中心开始月用于存补发的钱
        String mm专家中心截止时间  = jingfeiJingfeipiciyueMapper.findMaxJiezhiTimeByPiciId(ppPiciId);

        SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
        String mm截止时间  = ft.format(mm批次.getJiezhishijian());

        // 查询新的变动
        List<Map<String,Object>> 超期变动专家集合 = renwuMapper.findNEWBiandongByJieshuTime(deptid,mm专家中心截止时间,mm截止时间);

        List<String> mm单位id集合 = Arrays.asList(mmdeptIds);
        List<String> mm专家id集合 = Arrays.asList(mmzhuanjiaIds);

        // 循环变动 如果这个变动属于当前发放的单位 则编辑为已使用
        List<String> mm经费单位id集合 =  new ArrayList<>();
        List<String> mm变动id集合 =  new ArrayList<>();
        for (Map<String,Object> 变动one:超期变动专家集合) {
            String mm变动id = 变动one.get("shenbaoid") == null ? "" : 变动one.get("shenbaoid").toString();
            String mm单位id = 变动one.get("deptid") == null ? "" : 变动one.get("deptid").toString();
            String mm单位id2 = 变动one.get("deptid2") == null ? "" : 变动one.get("deptid2").toString();
            String mm单位id3 = 变动one.get("deptid3") == null ? "" : 变动one.get("deptid3").toString();
            if(mm单位id集合.contains(mm单位id)||mm单位id集合.contains(mm单位id2)||mm单位id集合.contains(mm单位id3)){ // 这个变动是当前单位的变动现在发钱 那么这个变动设置为有效
                mm变动id集合.add(mm变动id);
            }
        }

        if(mm变动id集合.size()>0){
            zhuanjiabiandongshenbaoMapper.UpdateFafangByIds(mm变动id集合);
        }


        // 查询到本单位的所有的下级单位的本批次的经费单位
        List<Map<String,Object>> 变动单位集合 = jingfeiDeptMapper.findDeptJFByParentId(ppPiciId,deptid);
        for (Map<String,Object> 变动单位one:变动单位集合) {
            String mm经费单位id = 变动单位one.get("id") == null ? "" : 变动单位one.get("id").toString();
            String mm单位id = 变动单位one.get("deptid") == null ? "" : 变动单位one.get("deptid").toString();
            if(mm单位id集合.contains(mm单位id)){ // 这个变动是当前单位的变动现在发钱 那么这个变动设置为有效
                mm经费单位id集合.add(mm经费单位id);
            }
        }

        // 在本批次的单位 的是否发放 发放时间修改掉
        long 发给单位的钱 = 0;
        if(mm经费单位id集合.size()>0){
            jingfeiDeptMapper.UpdateFafangByIds(mm经费单位id集合);
            Object mmCount = jingfeiDeptMapper.countFafangByIds(mm经费单位id集合); // 查询发给发给单位的钱
            发给单位的钱 = mmCount == null ? 0 : Long.parseLong(mmCount.toString().replace(".0",""));
        }

        // 判断本批次是否全额发放
        JingfeiDept mm查询条件 = new JingfeiDept();
        mm查询条件.setJingfeipiciid(ppPiciId);
        mm查询条件.setIsshangjifafang(0l);
        List<JingfeiDept> mm未发集合 = jingfeiDeptMapper.selectJingfeiDeptList(mm查询条件);
        if(mm未发集合.size()>0){ //存在尚未发放的经费单位
            mm批次.setIsfafang(2l); // 没有发完
        }else{
            mm批次.setIsfafang(1l); // 发完钱
        }
        jingfeiJingfeipiciService.updateJingfeiJingfeipici(mm批次);

        // 这一步判断传进来的专家是本单位直接下属的专家  只有本单位下属的才能直接发钱
        List<String> mm经费专家id集合 =  new ArrayList<>();
        JingfeiZhuanjia mm专家查询条件 = new JingfeiZhuanjia();
        mm专家查询条件.setJingfeipiciid(ppPiciId);
        mm专家查询条件.setDeptid(deptid);
        List<JingfeiZhuanjia> mm下属专家 = jingfeiZhuanjiaMapper.selectJingfeiZhuanjiaList(mm专家查询条件);  // 这个批次本单位的专家经费
        for (JingfeiZhuanjia 下属专家:mm下属专家) {
            if(mm专家id集合.contains(下属专家.getZhuanjiaid())){
                mm经费专家id集合.add(下属专家.getId());
            }
        }


        long 发给专家的钱 = 0;
        // 更新经费单位记录 查询本次发放的经费
        if(mm经费专家id集合.size()>0){
            jingfeiZhuanjiaMapper.UpdateFafangByIds(mm经费专家id集合);
            Object mmCount = jingfeiZhuanjiaMapper.countFafangByIds(mm经费专家id集合); // 查询发给专家的钱
            发给专家的钱 = mmCount == null ? 0 : Long.parseLong(mmCount.toString().replace(".0",""));
        }

       JingfeiDanweijingfei mm当前 = jingfeiDanweijingfeiService.selectJingfeiDanweijingfeiByDeptid(deptid);
        System.out.println("原本："+mm当前.getZongjingfei());
        System.out.println("发给专家的钱："+发给专家的钱);
        System.out.println("发给单位的钱："+发给单位的钱);

        // 发钱做两个操作 一个总经费减去发出去的    2是已发经费加上发出去的
        mm当前.setZongjingfei(mm当前.getZongjingfei()-发给专家的钱);
        mm当前.setYifajingfei(mm当前.getYifajingfei()+发给专家的钱+发给单位的钱);

        // 查询最新的滞留总额
        Object mm滞留all = jingfeiZhiliuMapper.countZLByDeptId(deptid);
        long 滞留all = mm滞留all == null ? 0 : Long.parseLong(mm滞留all.toString().replace(".0",""));
        System.out.println("滞留all："+滞留all);
        mm当前.setJieyujingfei(滞留all);
        mm当前.setDaifajingfei(mm当前.getDaifajingfei()+发给单位的钱); // 要发给单位的钱 和之前剩余的代发
        jingfeiDanweijingfeiService.updateJingfeiDanweijingfei(mm当前);


        // 发放专家经费
        return  BooleanMessage.getSuccessMessage("发放成功");
    }


    // 专家中心进行经费计算 只计算本批次的总金额 和专家月份钱
    @Override
    @Transactional
    public BooleanMessage DEPTJingfeijisuan(String ppPiciId, String ppDeptId) { //传值批次id
        Dept mm当前审批= deptService.selectDeptByDeptid(ppDeptId);
        Map<String,Object> mmMap = new HashMap<>();
        // 删除旧的计算数据  等写完再看涉及到的表和数据
        JingfeiJingfeipici  mm批次 = jingfeiJingfeipiciService.selectJingfeiJingfeipiciByJingfeipiciid(ppPiciId);                   // 查询批次   查询批次的月份
        if(mm批次.getIsfafang()==1){
            return BooleanMessage.getErrorMessage("当前批次已发放！");
        }else if(mm批次.getIsjisuan()==1){
            jingfeiZhuanjiaMonthMapper.deleteByPiciId(ppPiciId);
            jingfeiZhuanjiaMonthMapper.deleteJFDdptMonthByPiciId(ppPiciId);
            jingfeiZhuanjiaMonthMapper.deleteZJByPiciId(ppPiciId);
            jingfeiZhuanjiaMonthMapper.deleteJFDdptByPiciId(ppPiciId);
        }
        // 因为存在跨区域  获取最后的专家中心变动截止时间  获取最小的专家中心开始月用于存补发的钱
        String 初始月 = jingfeiJingfeipiciyueMapper.findMinyueByPiciId(ppPiciId);
        String mm专家中心截止时间  = jingfeiJingfeipiciyueMapper.findMaxJiezhiTimeByPiciId(ppPiciId);

        SimpleDateFormat NYR = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat NY = new SimpleDateFormat("yyyy-MM");
        String mm截止时间  = NYR.format(mm批次.getJiezhishijian()); // 本批次的截止时间

        JingfeiJingfeipiciyue mm月份查询条件 = new JingfeiJingfeipiciyue();
        mm月份查询条件.setJingfeipiciid(ppPiciId);
        List<JingfeiJingfeipiciyue> mm包含月份 = jingfeiJingfeipiciyueService.selectJingfeiJingfeipiciyueList(mm月份查询条件);    // 查询批次包含月份
        List<JingfeiZhuanjiaMonth> OLD专家月经费集合 = new ArrayList<>();
        // 下级单位存在跨批次发钱 每个月批次不固定
        for (JingfeiJingfeipiciyue mmYue: mm包含月份) {
            // 获得每个批次的月份的时间 和上一个发钱下来的批次id 完整拷贝
            String 上一个批次id = mmYue.getBeizhu1();
            String mm月份时间 = NY.format(mmYue.getNianyue()); // 获得时间
            List<JingfeiZhuanjiaMonth> OLD专家月经费One = jingfeiZhuanjiaMonthMapper.findByPiciIdAndLikeBeizhu1AndNY(上一个批次id,"%@"+ppDeptId+"@%",mm月份时间);
            OLD专家月经费集合.addAll(OLD专家月经费One);
        }

        long 月额度 = 600;   // 每月经费先写死成600
        // 查询新的变动
        List<Map<String,Object>> 超期变动专家集合 = renwuMapper.findNEWBiandongByJieshuTime(ppDeptId,mm专家中心截止时间,mm截止时间);
        Map<String,Object> mm变动信息集合 = DeptBiandongJisuan(mm包含月份,超期变动专家集合,月额度,mm批次.getJingfeipiciid(),mm批次.getPicimingcheng(),mm当前审批.getDeptname(),ppDeptId);
        List<JingfeiZhuanjiaMonth> 变动输出专家月 = mm变动信息集合.get("输出专家月")==null?null: (List<JingfeiZhuanjiaMonth>)mm变动信息集合.get("输出专家月");
        List<String> 变动专家id集合 = mm变动信息集合.get("变动专家id集合")==null?null: (List<String>)mm变动信息集合.get("变动专家id集合");
        List<JingfeiZhiliu> 滞留经费集合 = mm变动信息集合.get("滞留经费")==null?null: (List<JingfeiZhiliu>)mm变动信息集合.get("滞留经费");
        List<JingfeiZhuanjiaMonth> 拷贝专家月经费集合 = new ArrayList<>();


        List<String> mm上级发了钱的专家经费 = new ArrayList<>();
        for (JingfeiJingfeipiciyue mm月:mm包含月份) {
            String 当前月 = NY.format(mm月.getNianyue()); //获得月份 yyyy-mm

            for (JingfeiZhuanjiaMonth mm专家单月经费:OLD专家月经费集合 ) {  // 循环所有的专家
                String 当前经费月份 = NY.format(mm专家单月经费.getNianyue());

                if(!变动专家id集合.contains(mm专家单月经费.getZhuanjiaid())){ //该专家不是新变动专家
                    if(当前月.equals(初始月)){ // 是专家中心的最初批次  则等于与小于都加入
                        if(当前经费月份.compareTo(当前月)<=0){ // 如果当前的经费月份在当前月的前面 或者等于这个月  都拷贝
                            JingfeiZhuanjiaMonth mmadd = mm专家单月经费;
                            mmadd.setId(UUID.randomUUID().toString());
                            mmadd.setJingfeipiciid(ppPiciId);
                            mmadd.setJingfeipiciname(mm批次.getPicimingcheng());
                            拷贝专家月经费集合.add(mmadd);
                        }
                    }else{ // 不是初始月  则只有相等才录入
                        if(当前经费月份.equals(当前月)){ // 如果当前的经费月份等于当前月 都拷贝
                            JingfeiZhuanjiaMonth mmadd = mm专家单月经费;
                            mmadd.setId(UUID.randomUUID().toString());
                            mmadd.setJingfeipiciid(ppPiciId);
                            mmadd.setJingfeipiciname(mm批次.getPicimingcheng());
                            拷贝专家月经费集合.add(mmadd);
                        }
                    }
                }else{
                    // 保存一个变动的专家经费集合 // 新的经费必须存在其中才能 添加 没有就证明上级没发这个钱
                    if(当前经费月份.equals(当前月)){
                        mm上级发了钱的专家经费.add(mm专家单月经费.getZhuanjiaid()+"||"+当前月);
                    }
                }
            }
        }
        // 上级单位就没发  这次就更发不出去
        Iterator<JingfeiZhuanjiaMonth> iterator = 变动输出专家月.iterator();
        while (iterator.hasNext()) {
            JingfeiZhuanjiaMonth mmone = iterator.next();
            String 当前月份 = NY.format(mmone.getNianyue());
            if(mmone.getIstingfa()==0){ //正常发放的
                String pipei = mmone.getZhuanjiaid()+"||"+当前月份;
                if(!mm上级发了钱的专家经费.contains(pipei)){
                    iterator.remove();
                }
            }
        }

        // 查询之前的滞留 如果相同时间的专家id和时间 存在了 就不需要添加
        Iterator<JingfeiZhiliu> JingfeiZhiliuiterator = 滞留经费集合.iterator();
        List<String> mm已存在滞留 = jingfeiZhiliuMapper.findZhiliu();
        while (JingfeiZhiliuiterator.hasNext()) {
            JingfeiZhiliu mmone = JingfeiZhiliuiterator.next();
            String 当前月份 = NY.format(mmone.getNianyue());
            if(mm已存在滞留.contains(mmone.getZhuanjiaid()+当前月份)){
                JingfeiZhiliuiterator.remove();
            }
        }
        // 添加滞留经费
        if(滞留经费集合.size()>0){
            jingfeiZhiliuMapper.insertBatch(滞留经费集合);
        }

        // 原本想写专家中心发的钱里有这些人  才能发出来   但是 变动只有扣  也就无所谓了
        拷贝专家月经费集合.addAll(变动输出专家月);
        if(拷贝专家月经费集合.size()>0){
            jingfeiZhuanjiaMonthMapper.insertBatch(拷贝专家月经费集合);  // 添加专家经费月
        }

        // 添加好经费月  开始准备添加经费专家
        List<Map<String,Object>> mm专家经费明细 = jingfeiZhuanjiaMonthMapper.findZhuanjiaJFByPiciId(ppPiciId);
        List<JingfeiZhuanjia> mm专家经费集合 = Biandongzhuanjia(mm专家经费明细,mm批次);

        if(mm专家经费集合.size()>0){
            jingfeiZhuanjiaMapper.insertBatch(mm专家经费集合);
        }
        // 添加经费单位月  查询所有的专家月
        List<Map<String,Object>> mm单位经费明细 = jingfeiZhuanjiaMonthMapper.findDeptJFMXByPiciId(ppPiciId);
        // 添加经费单位月  查询所有的专家月 有单位确认与延时条件
//        List<Map<String,Object>> mm单位经费明细 = jingfeiZhuanjiaMonthMapper.findDeptJFMXByPiciIdTiaojian(ppPiciId);
        Dept mm单位查询条件 = new Dept();
        mm单位查询条件.setParentid(ppDeptId);
        List<Dept> mm当前单位下级 = deptService.selectDeptList(mm单位查询条件);
        //查询条件中加入该批次已确认单位条件，传批次ID
        //List<Dept> mm当前单位下级 = deptService.findYiquerenDeptByPiciAndParentId(ppDeptId,ppPiciId);

        List<JingfeiDeptMonth> mm经费单位月 = BiandongDeptYueJF(mm单位经费明细,mm当前单位下级,mm包含月份,mm批次);
        if(mm经费单位月.size()>0){
            jingfeiDeptMonthMapper.insertBatch(mm经费单位月);
        }
        // 查询经费单位
        List<Map<String,Object>> mm单位经费明细总 = jingfeiDeptMapper.findDeptJFByPiciId(ppPiciId);
        // 查询经费单位 有单位确认与延时条件
//        List<Map<String,Object>> mm单位经费明细总 = jingfeiDeptMapper.findDeptJFByPiciIdTiaojian(ppPiciId);
        List<JingfeiDept> mm经费单位 =  BiandongDeptJF(mm单位经费明细总,mm当前单位下级,mm批次);
        if(mm经费单位.size()>0){
            jingfeiDeptMapper.insertBatch(mm经费单位);
        }

        Object mmCount = jingfeiZhuanjiaMonthMapper.getPiciJingfeiSum(ppPiciId); // 查出来所有的经费总额
        //Object mmCount = jingfeiZhuanjiaMonthMapper.getPiciJingfeiSumTiaojian(ppPiciId); // 查出来所有的经费总额 条件
        long 总经费 =  mmCount == null ? 0 : Long.parseLong(mmCount.toString().replace(".0",""));

        Object mmCount2 = jingfeiZhuanjiaMonthMapper.getPiciBFJingfeiSum(ppPiciId);
        //Object mmCount2 = jingfeiZhuanjiaMonthMapper.getPiciBFJingfeiSumTiaojian(ppPiciId);
        long 补发经费 =  mmCount2 == null ? 0 : Long.parseLong(mmCount2.toString().replace(".0",""));

        Object mmCount3 = jingfeiZhuanjiaMonthMapper.countzongrenshu(ppPiciId);
        //Object mmCount3 = jingfeiZhuanjiaMonthMapper.countzongrenshuTiaojian(ppPiciId);
        long 总人数 =  mmCount3 == null ? 0 : Long.parseLong(mmCount3.toString());

//        Object mmCount4 = jingfeiZhuanjiaMonthMapper.countzlrenshu(ppPiciId);
//        //Object mmCount4 = jingfeiZhuanjiaMonthMapper.countzlrenshuTiaojian(ppPiciId);
//        long 转隶的人数 =  mmCount4 == null ? 0 : Long.parseLong(mmCount4.toString()); // 转隶过来的人

        System.out.println("总人数："+总人数);
        System.out.println("转隶的人数：");
        mm批次.setIsjisuan((long)1);
        mm批次.setShifajine(总经费);
        mm批次.setShifarenshu(总人数);
        mm批次.setBufajine(补发经费);

        jingfeiJingfeipiciService.updateJingfeiJingfeipici(mm批次);

        System.out.println("chushi:"+初始月);
        System.out.println("chushi2:"+mm专家中心截止时间);

        System.out.println("chushi3:"+mm截止时间);
        System.out.println(超期变动专家集合);
        for (int i = 0; i < 变动输出专家月.size(); i++) {
            System.out.println(变动输出专家月);
        }
        return BooleanMessage.getSuccessMessage("计算成功");
    }

    // 单位变动计算 所有存在变动的专家信息
    public Map<String,Object> DeptBiandongJisuan (List<JingfeiJingfeipiciyue> mm包含月份,List<Map<String,Object>> mm变动专家List,
                                                      long mm经费,String mmPiciid,String piciName,String deptname,String ppPiciDeptId) {
        Map<String,Object> mm输出 = new HashMap<>();
        List<String> 停发专家id = new ArrayList<>();
        List<String> 补发专家id = new ArrayList<>();
        List<String> 变动专家id = new ArrayList<>();
        List<String> 发放记录合计 = new ArrayList<>();
        List<String> 变动id集合 = new ArrayList<>();
        List<JingfeiZhiliu> 经费滞留 = new ArrayList<>();

        List<JingfeiZhuanjiaMonth> 输出专家月 = new ArrayList<>();
        for (int i = 0; i < mm变动专家List.size(); i++) {
            Map<String, Object> 变动专家One = mm变动专家List.get(i);
            String mm申报id = 变动专家One.get("shenbaoid") == null ? "" : 变动专家One.get("shenbaoid").toString();
            String mm专家id = 变动专家One.get("zhuanjiaid") == null ? "" : 变动专家One.get("zhuanjiaid").toString();
            String mm姓名 = 变动专家One.get("xingming") == null ? "" : 变动专家One.get("xingming").toString();
            String mm单位id = 变动专家One.get("deptid") == null ? "" : 变动专家One.get("deptid").toString();
            String mm变动时间 = 变动专家One.get("biandongshijian") == null ? "" : 变动专家One.get("biandongshijian").toString();
            String mm变动类型 = 变动专家One.get("biandongleixing") == null ? "" : 变动专家One.get("biandongleixing").toString();
            String mm单位id2 = 变动专家One.get("deptid2") == null ? "" : 变动专家One.get("deptid2").toString();
            String mm单位id3 = 变动专家One.get("deptid3") == null ? "" : 变动专家One.get("deptid3").toString();

            SimpleDateFormat zm = new SimpleDateFormat("yyyy-MM");
            变动专家id.add(mm专家id);
            // 进行类型判断  类型为停发则正常停止发放
            if (mm变动类型.equals("1") || mm变动类型.equals("2") || mm变动类型.equals("3") || mm变动类型.equals("4") || mm变动类型.equals("5") || mm变动类型.equals("6")) {

                if (!补发专家id.contains(mm专家id)) { // 如果之前存在未处理的补发 就不进行操作
                    if(停发专家id.contains(mm专家id)){ // 如果之前被停发了 不需要做经费的操作  但是需要录入变动id
                        变动id集合.add(mm申报id);
                    }else{
                        for (int a = 0; a < mm包含月份.size(); a++) {
                            Date mm当前月份 = mm包含月份.get(a).getNianyue();
                            String mm本月份 = zm.format(mm当前月份);
                            String mm截止月份 = mm变动时间;
                            String mm本月份专家中心id = mm包含月份.get(a).getZjzxpiciid();

                            if (mm本月份.compareTo(mm截止月份) <= 0) { // 如果本月份在变动月份前边或相等  则发钱
                                JingfeiZhuanjiaMonth mm新专家月份 = new JingfeiZhuanjiaMonth();
                                mm新专家月份.setId(UUID.randomUUID().toString());
                                mm新专家月份.setJingfeipiciid(mmPiciid);
                                mm新专家月份.setJingfeipiciname(piciName);
                                mm新专家月份.setDeptid(mm单位id);
                                mm新专家月份.setZhuanjiaid(mm专家id);
                                mm新专家月份.setName(mm姓名);
                                mm新专家月份.setNianyue(mm当前月份);
                                mm新专家月份.setFafangjine(mm经费);
                                mm新专家月份.setBufajine((long) 0);
                                mm新专家月份.setIsbufa((long) 0);
                                mm新专家月份.setIstingfa((long) 0);
                                mm新专家月份.setZjzxpiciid(mm本月份专家中心id);
                                mm新专家月份.setBeizhu1("@" + mm单位id + "@" + "@" + mm单位id2 + "@" + "@" + mm单位id3 + "@");
                                输出专家月.add(mm新专家月份);
                            }else{
                                JingfeiZhiliu mmadd =  new JingfeiZhiliu();
                                mmadd.setId(UUID.randomUUID().toString());
                                mmadd.setZhuanjiaid(mm专家id);
                                mmadd.setNianyue(mm当前月份);
                                mmadd.setDangqiandeptid(ppPiciDeptId);
                                mmadd.setjine(mm经费);
                                mmadd.setPiciid(mmPiciid);
                                mmadd.setZjzxpiciid(mm本月份专家中心id);
                                mmadd.setTingfadeptid(ppPiciDeptId);
                                mmadd.setTingfadeptname(deptname);
                                mmadd.setZhuangtai(1l);
                                经费滞留.add(mmadd);
                            }
                        }
                    }

                }
                停发专家id.add(mm专家id);
            }else if(mm变动类型.equals("7") || mm变动类型.equals("9")){
                补发专家id.add(mm专家id);
            }
        }
        mm输出.put("变动id集合",变动id集合);
        mm输出.put("输出专家月",输出专家月);
        mm输出.put("发放记录合计",发放记录合计);
        mm输出.put("变动专家id集合",变动专家id);
        mm输出.put("滞留经费",经费滞留);
        return mm输出;
    }

    // 专家中心进行经费计算 只计算本批次的总金额 和专家月份钱
    @Override
    @Transactional
    public Map<String,Object> fafanglist(String ppPiciId,String ppDeptId) { //传值批次id
        Map<String,Object> fafanglist = new HashMap<>();
        JingfeiZhuanjia mm查询条件 = new JingfeiZhuanjia();
        mm查询条件.setJingfeipiciid(ppPiciId);
        mm查询条件.setDeptid(ppDeptId);
        List<JingfeiZhuanjia>  mm集合 = jingfeiZhuanjiaMapper.selectJingfeiZhuanjiaList(mm查询条件);
        List<Map<String,Object>> mm单位 = jingfeiDeptMapper.findFFByPiciIdAndDeptId(ppPiciId,ppDeptId);
        fafanglist.put("zhuanjialist",mm集合);
        fafanglist.put("deptlist",mm单位);
        return fafanglist;
    }

    @Override
    @Transactional
    public BooleanMessage fafang(String ppPiciId,String deptid,String[] mmdeptIds,String[] mmzhuanjiaIds) { //传值批次id
        JingfeiJingfeipici  mm批次 = jingfeiJingfeipiciService.selectJingfeiJingfeipiciByJingfeipiciid(ppPiciId);                   // 查询批次 、
//        if(mm批次.getJiezhishijian().compareTo(new Date())<0){
//            return BooleanMessage.getErrorMessage("截止时间之后才可计算和发放经费");
//        }
        // 如果之前已经发放过 就不需要重新跑计算
//        if(mm批次.getIsfafang()==0){
//            BooleanMessage mm计算 = ZJZXJingfeijisuan(ppPiciId,deptid);
//            if(!mm计算.isOk()){ return mm计算;}
//        }
        Date mm截止时间  = mm批次.getJiezhishijian();
        SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
        String 截止时间 = ft.format(mm截止时间);
        // 将日期改为当月最后一天  用来判断变动是否在本月内发生
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        String 批次结束月 = (String) renwuMapper.getMAxJieshumouth(ppPiciId);
        LocalDate localDate = LocalDate.parse(批次结束月, formatter);
        LocalDate lastDayOfMonth = localDate.with(TemporalAdjusters.lastDayOfMonth()); // 获取当前月份的最后一天
        String 结束月最后一天 = lastDayOfMonth.format(formatter);
        List<Map<String,Object>> 变动专家集合 = renwuMapper.findBiandongByJieshuTime(截止时间,结束月最后一天);   // 获得所有的变动
        List<String> mm单位id集合 = Arrays.asList(mmdeptIds);
        List<String> mm专家id集合 = Arrays.asList(mmzhuanjiaIds);
        // 循环变动 如果这个变动属于当前发放的单位 则编辑为已使用
        List<String> mm经费单位id集合 =  new ArrayList<>();
        List<String> mm变动id集合 =  new ArrayList<>();
        for (Map<String,Object> 变动one:变动专家集合) {
            String mm变动id = 变动one.get("shenbaoid") == null ? "" : 变动one.get("shenbaoid").toString();
            String mm单位id = 变动one.get("deptid") == null ? "" : 变动one.get("deptid").toString();
            String mm单位id2 = 变动one.get("deptid2") == null ? "" : 变动one.get("deptid2").toString();
            String mm单位id3 = 变动one.get("deptid3") == null ? "" : 变动one.get("deptid3").toString();
            if(mm单位id集合.contains(mm单位id)||mm单位id集合.contains(mm单位id2)||mm单位id集合.contains(mm单位id3)){ // 这个变动是当前单位的变动现在发钱 那么这个变动设置为有效
              mm变动id集合.add(mm变动id);
            }
        }
        if(mm变动id集合.size()>0){
            zhuanjiabiandongshenbaoMapper.UpdateFafangByIds(mm变动id集合);
        }

        // 查询到本单位的所有的下级单位的本批次的经费单位 在本批次的单位 的是否发放 发放时间修改掉
        List<Map<String,Object>> 变动单位集合 = jingfeiDeptMapper.findDeptJFByParentId(ppPiciId,deptid);
        for (Map<String,Object> 变动单位one:变动单位集合) {
            String mm变动单位id = 变动单位one.get("id") == null ? "" : 变动单位one.get("id").toString();
            String mm单位id = 变动单位one.get("deptid") == null ? "" : 变动单位one.get("deptid").toString();
            if(mm单位id集合.contains(mm单位id)){ // 这个变动是当前单位的变动现在发钱 那么这个变动设置为有效
                mm经费单位id集合.add(mm变动单位id);
            }
        }

        if(mm经费单位id集合.size()>0){
            jingfeiDeptMapper.UpdateFafangByIds(mm经费单位id集合);
        }

        // 判断本批次是否全额发放
        JingfeiDept mm查询条件 = new JingfeiDept();
        mm查询条件.setJingfeipiciid(ppPiciId);
        mm查询条件.setIsshangjifafang(0l);
        List<JingfeiDept> mm未发集合 = jingfeiDeptMapper.selectJingfeiDeptList(mm查询条件);
        if(mm未发集合.size()>0){ //存在尚未发放的经费单位
            mm批次.setIsfafang(2l);
        }else{
            mm批次.setIsfafang(1l);
        }
        List<String> mm经费专家id集合 =  new ArrayList<>();
        jingfeiJingfeipiciService.updateJingfeiJingfeipici(mm批次);
        // 判断专家
        JingfeiZhuanjia mm专家查询条件 = new JingfeiZhuanjia();
        mm专家查询条件.setJingfeipiciid(ppPiciId);
        mm专家查询条件.setDeptid(deptid);
        List<JingfeiZhuanjia> mm下属专家 = jingfeiZhuanjiaMapper.selectJingfeiZhuanjiaList(mm专家查询条件);
        for (JingfeiZhuanjia 下属专家:mm下属专家) {
            if(mm专家id集合.contains(下属专家.getZhuanjiaid())){
                mm经费专家id集合.add(下属专家.getId());
            }
        }
        if(mm经费专家id集合.size()>0){
            jingfeiZhuanjiaMapper.UpdateFafangByIds(mm经费专家id集合);
        }
        // 发放专家经费
        return  BooleanMessage.getSuccessMessage("发放成功");
    }

    // 专家中心进行经费计算 只计算本批次的总金额 和专家月份钱
    @Override
    @Transactional
    public List<Map<String,Object>> zjzxjfmx(String ppPiciId,String ppDeptId,String ppisshangjifafang,String isshoukuan,String deptname) { //传值批次id
        if(deptname!=null&&!deptname.equals("")){
            deptname ="%"+deptname+"%";
        }
        int INTisshangjifafang = 99;
        int INTshoukuan = 99;
        if(ppisshangjifafang!=null&&!ppisshangjifafang.equals("")){
            INTisshangjifafang = Integer.valueOf(ppisshangjifafang);
        }
        if(isshoukuan!=null&&!isshoukuan.equals("")){
            INTshoukuan = Integer.valueOf(isshoukuan);
        }
       return jingfeiDeptMapper.findMXByParentId(ppPiciId,ppDeptId,INTisshangjifafang,INTshoukuan,deptname);
    }



    // 专家中心进行经费计算 只计算本批次的总金额 和专家月份钱
    @Override
    @Transactional
    public BooleanMessage ZJZXJingfeijisuan(String ppPiciId, String ppDeptId) { //传值批次id

        Map<String,Object> mmMap = new HashMap<>();
        // 删除旧的计算数据  等写完再看涉及到的表和数据
        JingfeiJingfeipici  mm批次 = jingfeiJingfeipiciService.selectJingfeiJingfeipiciByJingfeipiciid(ppPiciId);                   // 查询批次   查询批次的月份
       if(mm批次.getIsfafang()==1){
           return BooleanMessage.getErrorMessage("当前批次已发放！");
       }else if(mm批次.getIsjisuan()==1){
           jingfeiZhuanjiaMonthMapper.deleteByPiciId(ppPiciId);
           jingfeiZhuanjiaMonthMapper.deleteJFDdptMonthByPiciId(ppPiciId);
           jingfeiZhuanjiaMonthMapper.deleteZJByPiciId(ppPiciId);
           jingfeiZhuanjiaMonthMapper.deleteJFDdptByPiciId(ppPiciId);
       }

        Date mm截止时间  = mm批次.getJiezhishijian();
        SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
        String 批次开始月 = (String) renwuMapper.getMinKaishimouth(ppPiciId);
        String 批次结束月 = (String) renwuMapper.getMAxJieshumouth(ppPiciId);

        List<Map<String,Object>> 全款专家集合 = renwuMapper.findzhengchangzhuanjia(ft.format(mm截止时间),批次开始月);             // 查询全款的正常的专家

        JingfeiJingfeipiciyue mm月份查询条件 = new JingfeiJingfeipiciyue();
        mm月份查询条件.setJingfeipiciid(ppPiciId);
        List<JingfeiJingfeipiciyue> mm包含月份 = jingfeiJingfeipiciyueService.selectJingfeiJingfeipiciyueList(mm月份查询条件);    // 查询批次包含月份
//        Canshu mm经费 = new Canshu();
//        mm经费.setCanshumingcheng("经费");
//        List<Canshu> mm经费集合 = dd参数Service.selectCanshuList(mm经费);
//        long fromString =Long.valueOf(mm经费集合.get(0).getCanshuzhi());                                            // 获得经费
        long 月额度 = 600;   // 表还没创建 先写死成600
        List<JingfeiZhuanjiaMonth> 专家月经费集合 = new ArrayList<>();   // 所有专家的经费月记录
        // 循环月份   // 循环专家
        for(int z = 0;z<全款专家集合.size();z++){
            String mm专家id  = 全款专家集合.get(z).get("zhuanjiaid")==null?"":全款专家集合.get(z).get("zhuanjiaid").toString();
            String mm姓名  = 全款专家集合.get(z).get("xingming")==null?"":全款专家集合.get(z).get("xingming").toString();
            String mm单位id  = 全款专家集合.get(z).get("deptid")==null?"":全款专家集合.get(z).get("deptid").toString();
            String mm单位id2  = 全款专家集合.get(z).get("deptid2")==null?"":全款专家集合.get(z).get("deptid2").toString();
            String mm单位id3  = 全款专家集合.get(z).get("deptid3")==null?"":全款专家集合.get(z).get("deptid3").toString();
            for(int i=0;i<mm包含月份.size();i++){
                Date mm当前月份 = mm包含月份.get(i).getNianyue();
                // 封装 专家月份
                JingfeiZhuanjiaMonth mm新专家月份 = new JingfeiZhuanjiaMonth();
                mm新专家月份.setId(UUID.randomUUID().toString());
                mm新专家月份.setJingfeipiciid(ppPiciId);
                mm新专家月份.setJingfeipiciname(mm批次.getPicimingcheng());
                mm新专家月份.setDeptid(mm单位id);
                mm新专家月份.setZhuanjiaid(mm专家id);
                mm新专家月份.setName(mm姓名);
                mm新专家月份.setNianyue(mm当前月份);
                mm新专家月份.setFafangjine(月额度);
                mm新专家月份.setBufajine((long)0);
                mm新专家月份.setIsbufa((long)0);
                mm新专家月份.setIstingfa((long)0);
                mm新专家月份.setZjzxpiciid(ppPiciId);
                mm新专家月份.setBeizhu1("@"+mm单位id+"@"+"@"+mm单位id2+"@"+"@"+mm单位id3+"@");
                专家月经费集合.add(mm新专家月份);
            }
        }
        // 将日期改为当月最后一天  用来判断变动是否在本月内发生
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        LocalDate localDate = LocalDate.parse(批次结束月, formatter);
        LocalDate lastDayOfMonth = localDate.with(TemporalAdjusters.lastDayOfMonth()); // 获取当前月份的最后一天
        String 结束月最后一天 = lastDayOfMonth.format(formatter);
        String 截止时间 = ft.format(mm截止时间);

        // 查询到所有的变动的专家
        List<Map<String,Object>> 变动专家集合 = renwuMapper.findBiandongByJieshuTime(截止时间,结束月最后一天);
        // 查询 受到变动影响专家状态变动但是实际上本批次尚未到变动时间 这批专家如在本期内无变动 则全款发放
        List<Map<String,Object>> 超期变动专家集合 = renwuMapper.findCQBiandongByJieshuTime(结束月最后一天);
        // 算出所有的专家月 并加入总集合里
        List<JingfeiZhuanjiaMonth> mm变动专家月份=BiandongJisuan(mm包含月份,变动专家集合,超期变动专家集合,月额度,ppPiciId,mm批次.getPicimingcheng(),批次结束月);

        专家月经费集合.addAll(mm变动专家月份);
        if(专家月经费集合.size()>0){
            jingfeiZhuanjiaMonthMapper.insertBatch(专家月经费集合);
        }

        // 添加好经费月  开始准备添加经费专家
        List<Map<String,Object>> mm专家经费明细 = jingfeiZhuanjiaMonthMapper.findZhuanjiaJFByPiciId(ppPiciId);
        List<JingfeiZhuanjia> mm专家经费集合 = Biandongzhuanjia(mm专家经费明细,mm批次);
        if(mm专家经费集合.size()>0){
            jingfeiZhuanjiaMapper.insertBatch(mm专家经费集合);
        }
        // 添加经费单位月  查询所有的专家月
        List<Map<String,Object>> mm单位经费明细 = jingfeiZhuanjiaMonthMapper.findDeptJFMXByPiciId(ppPiciId);
        Dept mm查询条件 = new Dept();
        mm查询条件.setParentid(RuoYiConfig.getZjzxdeptid());
        List<Dept> mm博管会下级 = deptService.selectDeptList(mm查询条件);
        //查询条件中加入该批次已确认单位条件，传批次ID
//        List<Dept> mm博管会下级 = deptService.findYiquerenDeptByPiciAndParentId(RuoYiConfig.getZjzxdeptid(),ppPiciId);

        List<JingfeiDeptMonth> mm经费单位月 = BiandongDeptYueJF(mm单位经费明细,mm博管会下级,mm包含月份,mm批次);
        if(mm经费单位月.size()>0){
            jingfeiDeptMonthMapper.insertBatch(mm经费单位月);
        }
        // 查询经费单位
        List<Map<String,Object>> mm单位经费明细总 = jingfeiDeptMapper.findDeptJFByPiciId(ppPiciId);
        List<JingfeiDept> mm经费单位 =  BiandongDeptJF(mm单位经费明细总,mm博管会下级,mm批次);
        if(mm经费单位.size()>0){
            jingfeiDeptMapper.insertBatch(mm经费单位);
        }

        Object mmCount = jingfeiZhuanjiaMonthMapper.getPiciJingfeiSum(ppPiciId); // 查出来所有的经费总额
        System.out.println("aaa:"+mmCount);
        long 总经费 =  mmCount == null ? 0 : Long.parseLong(mmCount.toString().replace(".0",""));
        System.out.println("bbb:"+总经费);

        Object mmCount2 = jingfeiZhuanjiaMonthMapper.getPiciBFJingfeiSum(ppPiciId);
        long 补发经费 =  mmCount2 == null ? 0 : Long.parseLong(mmCount2.toString().replace(".0",""));

        Object mmCount3 = jingfeiZhuanjiaMonthMapper.countzongrenshu(ppPiciId);
        long 总人数 =  mmCount3 == null ? 0 : Long.parseLong(mmCount3.toString());

//        Object mmCount4 = jingfeiZhuanjiaMonthMapper.countzlrenshu(ppPiciId);
//        long 转隶的人数 =  mmCount4 == null ? 0 : Long.parseLong(mmCount4.toString());

        mm批次.setIsjisuan((long)1);
        mm批次.setShifajine(总经费);
        mm批次.setShifarenshu(总人数);
        mm批次.setBufajine(补发经费);

        jingfeiJingfeipiciService.updateJingfeiJingfeipici(mm批次);
        return BooleanMessage.getSuccessMessage("计算成功");
    }

    // 博管会计算经费单位
    public List<JingfeiDept> BiandongDeptJF( List<Map<String,Object>> mm单位经费明细总,List<Dept> mm博管会下级,JingfeiJingfeipici mm经费批次){
        List<JingfeiDept> 单位经费集合 = new ArrayList<>();   // 所有专家的经费记录
        for (Dept deptone: mm博管会下级) {
            String deptid = "@"+deptone.getDeptid()+"@";
            JingfeiDept mm单位经费 =  new JingfeiDept();
            mm单位经费.setId(UUID.randomUUID().toString());
            mm单位经费.setJingfeipiciid(mm经费批次.getJingfeipiciid());
            mm单位经费.setDeptid(deptone.getDeptid());
            mm单位经费.setName(mm经费批次.getPicimingcheng());
            mm单位经费.setIsvalid(1l);
            mm单位经费.setIsshangjifafang(0l);
            mm单位经费.setIsshoukuan(0l);
            mm单位经费.setBeizhu1(mm经费批次.getBeizhu1());
            long 人数 =0;
            long 发放金额 = 0;
            long 补发金额 = 0;

            for (Map<String,Object> mm经费one: mm单位经费明细总) {   // 二层循环单位
                String mm序列编码 = mm经费one.get("beizhu1") == null ? "" : mm经费one.get("beizhu1").toString();
                String mm金额 = mm经费one.get("jine") == null ? "0" : mm经费one.get("jine").toString();
                String mm补发 = mm经费one.get("bufa") == null ? "0" : mm经费one.get("bufa").toString();
                String mm人数 = mm经费one.get("renshu") == null ? "0" : mm经费one.get("renshu").toString();
                if(mm序列编码.contains(deptid)){
                    long 具体金额 = Long.valueOf(mm金额.replace(".0",""));
                    long 具体补发金额 = Long.valueOf(mm补发.replace(".0",""));
                    long 具体人数 = Long.valueOf(mm人数.replace(".0",""));
                    发放金额 = 发放金额+具体金额;
                    补发金额 = 补发金额+具体补发金额;
                    人数 = 人数+具体人数;
                }
            }
            mm单位经费.setFafangrenshu(人数);
            mm单位经费.setBufajine(补发金额);
            mm单位经费.setFafangjine(发放金额);
            单位经费集合.add(mm单位经费);
        }
        return 单位经费集合;
    }

    // 博管会计算经费单位月
    public List<JingfeiDeptMonth> BiandongDeptYueJF( List<Map<String,Object>> mm变动经费,List<Dept> mm博管会下级,List<JingfeiJingfeipiciyue> mm包含月份,JingfeiJingfeipici mm经费批次){
        List<JingfeiDeptMonth> 专家经费集合 = new ArrayList<>();   // 所有专家的经费记录

        SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM");

        for (int i = 0; i < mm包含月份.size(); i++) {   // 将本批次的月份都加入集合   一层循环月份
            JingfeiJingfeipiciyue mm批次月 = mm包含月份.get(i);
            String mm日期 = ft.format(mm批次月.getNianyue());
            for (Dept deptone: mm博管会下级) {   // 二层循环单位
                String deptid = "@"+deptone.getDeptid()+"@";
                JingfeiDeptMonth mm全款单位月经费 = new JingfeiDeptMonth();
                long mm收款经费 = 0;
                mm全款单位月经费.setId(UUID.randomUUID().toString());
                mm全款单位月经费.setJingfeipiciid(mm经费批次.getJingfeipiciid());
                mm全款单位月经费.setDeptid(deptone.getDeptid());
                mm全款单位月经费.setName(mm经费批次.getPicimingcheng());
                mm全款单位月经费.setShoukuannianyue(mm批次月.getNianyue());
                mm全款单位月经费.setIsuse(0l);
                mm全款单位月经费.setIsqueren(0l);
                mm全款单位月经费.setZjzxpiciid(mm经费批次.getBeizhu1());
                mm全款单位月经费.setFafangjine(0l);

                for (Map<String,Object> mm变动单位月one: mm变动经费) {   // 三层循环 单位经费月
                    String mm单位id = mm变动单位月one.get("deptid") == null ? "" : mm变动单位月one.get("deptid").toString();
                    String mm年月 = mm变动单位月one.get("nianyue") == null ? "" : mm变动单位月one.get("nianyue").toString();
                    String mm序列编码 = mm变动单位月one.get("beizhu1") == null ? "" : mm变动单位月one.get("beizhu1").toString();
                    String mm金额 = mm变动单位月one.get("jine") == null ? "0" : mm变动单位月one.get("jine").toString();
                    if(mm序列编码.contains(deptid)){ // 包含了则就是本单位的经费
                        long 具体金额 = Long.valueOf(mm金额.replace(".0",""));
                        if(mm年月.equals(mm日期)||(i==0&&(mm年月.compareTo(mm日期) < 0))){ // 日期相同 或者这个是第一个月 比第一个月小的经费算第一个月
                            mm收款经费 =mm收款经费+具体金额;
                        }
                    }
                }
                mm全款单位月经费.setShoukuanjine(mm收款经费);
                mm全款单位月经费.setShengyujine(mm收款经费);
                专家经费集合.add(mm全款单位月经费);
            }
        }
        return 专家经费集合;
    }


    public List<JingfeiZhuanjia> Biandongzhuanjia( List<Map<String,Object>> mm变动专家,JingfeiJingfeipici mm经费批次){
        List<JingfeiZhuanjia> 专家经费集合 = new ArrayList<>();   // 所有专家的经费记录
        for (Map<String,Object> mm变动专家one: mm变动专家) {
            String mm专家id = mm变动专家one.get("zhuanjiaid") == null ? "" : mm变动专家one.get("zhuanjiaid").toString();
            String mm姓名 = mm变动专家one.get("name") == null ? "" : mm变动专家one.get("name").toString();
            String mm单位id = mm变动专家one.get("deptid") == null ? "" : mm变动专家one.get("deptid").toString();
            String mm单位id2 = mm变动专家one.get("deptid2") == null ? "" : mm变动专家one.get("deptid2").toString();
            String mm单位id3 = mm变动专家one.get("deptid3") == null ? "" : mm变动专家one.get("deptid3").toString();
            String mm金额 = mm变动专家one.get("jine") == null ? "0" : mm变动专家one.get("jine").toString();
            String mm补发金额 = mm变动专家one.get("bufajine") == null ? "0" : mm变动专家one.get("bufajine").toString();
            JingfeiZhuanjia mm全款专家经费 = new JingfeiZhuanjia();
            mm全款专家经费.setJingfeipiciid(mm经费批次.getJingfeipiciid());
            mm全款专家经费.setJingfeipiciname(mm经费批次.getPicimingcheng());
            mm全款专家经费.setIstingfa(0l);
            mm全款专家经费.setIsbufa(0l);
            mm全款专家经费.setBufajine(0l);
            mm全款专家经费.setZjzxpiciid(mm经费批次.getBeizhu1());
            mm全款专家经费.setShifoufafang(0l);
            mm全款专家经费.setId(UUID.randomUUID().toString());
            mm全款专家经费.setDeptid(mm单位id);
            mm全款专家经费.setZhuanjiaid(mm专家id);
            mm全款专家经费.setName(mm姓名);
            if(!mm补发金额.equals("0")){
                mm全款专家经费.setIsbufa(1l);
                mm全款专家经费.setBufajine(Long.valueOf(mm补发金额.replace(".0","")));

            }
            mm全款专家经费.setFafangjine(Long.valueOf(mm金额.replace(".0","")));
            mm全款专家经费.setBeizhu1("@"+mm单位id+"@"+"@"+mm单位id2+"@"+"@"+mm单位id3+"@");
            专家经费集合.add(mm全款专家经费);
        }
        return 专家经费集合;
    }
    // 变动计算 所有存在变动的专家信息
    public List<JingfeiZhuanjiaMonth> BiandongJisuan (List<JingfeiJingfeipiciyue> mm包含月份,List<Map<String,Object>> mm变动专家List,
                                                      List<Map<String,Object>> mm超期变动专家List,
                                                      long mm经费,String mmPiciid,String piciName,String picijieshuyue) {
        List<String> 增加或恢复专家id = new ArrayList<>();
        List<String> 已经执行过的专家id = new ArrayList<>();
        List<String> 停发专家id = new ArrayList<>();
        List<String> 转隶专家id = new ArrayList<>(); // 存的转隶的专家新id
        List<JingfeiZhuanjiaMonth> 输出专家月 = new ArrayList<>();
        for (int i = 0; i < mm变动专家List.size(); i++) {
            Map<String, Object> 变动专家One = mm变动专家List.get(i);
            String mm专家id = 变动专家One.get("zhuanjiaid") == null ? "" : 变动专家One.get("zhuanjiaid").toString();
            String mm姓名 = 变动专家One.get("xingming") == null ? "" : 变动专家One.get("xingming").toString();
            String mm单位id = 变动专家One.get("deptid") == null ? "" : 变动专家One.get("deptid").toString();
            String mm变动时间 = 变动专家One.get("biandongshijian") == null ? "" : 变动专家One.get("biandongshijian").toString();
            String mm变动类型 = 变动专家One.get("biandongleixing") == null ? "" : 变动专家One.get("biandongleixing").toString();
            String mm新专家id = 变动专家One.get("newzhuanjiaid") == null ? "" : 变动专家One.get("newzhuanjiaid").toString();
            String mm新单位id = 变动专家One.get("newdeptid") == null ? "" : 变动专家One.get("newdeptid").toString();
            String mm停发时间 = 变动专家One.get("tingfashijian") == null ? "" : 变动专家One.get("tingfashijian").toString();
            String mm入选年份 = 变动专家One.get("ruxuannianfen") == null ? "" : 变动专家One.get("ruxuannianfen").toString();
            String mm单位id2 = 变动专家One.get("deptid2") == null ? "" : 变动专家One.get("deptid2").toString();
            String mm单位id3 = 变动专家One.get("deptid3") == null ? "" : 变动专家One.get("deptid3").toString();
            String mm单位id4 = 变动专家One.get("deptid4") == null ? "" : 变动专家One.get("deptid4").toString();
            String mm单位id5 = 变动专家One.get("deptid5") == null ? "" : 变动专家One.get("deptid5").toString();
            已经执行过的专家id.add(mm专家id);
            SimpleDateFormat zm = new SimpleDateFormat("yyyy-MM");
            // 进行类型判断  类型为停发则正常停止发放
            if (mm变动类型.equals("1") || mm变动类型.equals("2") || mm变动类型.equals("3") || mm变动类型.equals("4") || mm变动类型.equals("5") || mm变动类型.equals("6")) {
                if (!停发专家id.contains(mm专家id)) { // 如果之前停发过就不需要处理 之后之前不是停发的才判断
                    for (int a = 0; a < mm包含月份.size(); a++) {
                        Date mm当前月份 = mm包含月份.get(a).getNianyue();
                        String mm本月份 = zm.format(mm当前月份);
                        String mm截止月份 = mm变动时间;
                        if (mm本月份.compareTo(mm截止月份) <= 0) { // 如果本月份在变动月份前边或相等  则发钱
                            JingfeiZhuanjiaMonth mm新专家月份 = new JingfeiZhuanjiaMonth();
                            mm新专家月份.setId(UUID.randomUUID().toString());
                            mm新专家月份.setJingfeipiciid(mmPiciid);
                            mm新专家月份.setJingfeipiciname(piciName);
                            mm新专家月份.setDeptid(mm单位id);
                            mm新专家月份.setZhuanjiaid(mm专家id);
                            mm新专家月份.setName(mm姓名);
                            mm新专家月份.setNianyue(mm当前月份);
                            mm新专家月份.setFafangjine(mm经费);
                            mm新专家月份.setBufajine((long) 0);
                            mm新专家月份.setIsbufa((long) 0);
                            mm新专家月份.setIstingfa((long) 0);
                            mm新专家月份.setZjzxpiciid(mmPiciid);
                            mm新专家月份.setBeizhu1("@"+mm单位id+"@"+"@"+mm单位id2+"@"+"@"+mm单位id3+"@");

                            输出专家月.add(mm新专家月份);
                        }
                    }
                }
                if (增加或恢复专家id.contains(mm专家id)) {
                    // 如果之前是补发或者转隶之类的专家 钱会给足 需要删除 超期的
                    for (int j = 0; j < 输出专家月.size(); j++) {
                        JingfeiZhuanjiaMonth mmOne = 输出专家月.get(j);
                        String 专家id = mmOne.getZhuanjiaid();
                        if (专家id.equals(mm专家id)) {
                            String mm当前记录的月份 = zm.format(mmOne.getNianyue());
                            if (mm变动时间.compareTo(mm当前记录的月份) < 0) { // 如果变动月份在这条记录的月份的前边  则删除
                                输出专家月.remove(j);
                                j = j - 1;
                            }
                        }
                    }
                    增加或恢复专家id.removeIf(s -> s.equals(mm专家id)); // 在停发之前是增加  防止第三次变动无法判断之前的状态 只保留最新的变动状态
                }
                if (转隶专家id.contains(mm专家id)) {
                    // 如果之前是补发或者转隶之类的专家 钱会给足 需要删除 超期的
                    for (int j = 0; j < 输出专家月.size(); j++) {
                        JingfeiZhuanjiaMonth mmOne = 输出专家月.get(j);
                        String 专家id = mmOne.getZhuanjiaid();
                        if (专家id.equals(mm专家id)) {
                            String mm当前记录的月份 = zm.format(mmOne.getNianyue());
                            if (mm变动时间.compareTo(mm当前记录的月份) < 0) { // 如果变动月份在这条记录的月份的前边  则删除
                                输出专家月.remove(j);
                                j = j - 1;
                            }
                        }
                    }
                    转隶专家id.removeIf(s -> s.equals(mm专家id)); // 在停发之前是增加  防止第三次变动无法判断之前的状态 只保留最新的变动状态
                }

                停发专家id.add(mm专家id); // 将停发的专家加入记录

            } else if (mm变动类型.equals("7")) { //恢复发放
                //恢复发放  之前是停发 时间由系统选择的 不管
                JingfeiZhuanjiaMonth mm新专家月份 = new JingfeiZhuanjiaMonth();
//                mm新专家月份.setId(UUID.randomUUID().toString());
                mm新专家月份.setJingfeipiciid(mmPiciid);
                mm新专家月份.setJingfeipiciname(piciName);
                mm新专家月份.setDeptid(mm单位id);
                mm新专家月份.setZhuanjiaid(mm专家id);
                mm新专家月份.setName(mm姓名);
                mm新专家月份.setZjzxpiciid(mmPiciid);
                mm新专家月份.setBeizhu1("@"+mm单位id+"@"+"@"+mm单位id2+"@"+"@"+mm单位id3+"@");
                List<JingfeiZhuanjiaMonth> mm恢复List = addzhuanjiamonth(mm停发时间,picijieshuyue,mm新专家月份,100,600);
                输出专家月.addAll(mm恢复List);
                增加或恢复专家id.add(mm专家id);
                if(停发专家id.contains(mm专家id)){ // 在补发之前是停发  防止第三次变动无法判断之前的状态 只保留最新的变动状态
                    停发专家id.removeIf(s -> s.equals(mm专家id));
                }
            }else if (mm变动类型.equals("9")) {//新增专家
                // 新增的专家不存在之前的状态 无需考虑之前的情况
                JingfeiZhuanjiaMonth mm新专家月份 = new JingfeiZhuanjiaMonth();

                mm新专家月份.setJingfeipiciid(mmPiciid);
                mm新专家月份.setJingfeipiciname(piciName);
                mm新专家月份.setDeptid(mm单位id);
                mm新专家月份.setZhuanjiaid(mm专家id);
                mm新专家月份.setName(mm姓名);
                mm新专家月份.setZjzxpiciid(mmPiciid);
                mm新专家月份.setBeizhu1("@"+mm单位id+"@"+"@"+mm单位id2+"@"+"@"+mm单位id3+"@");
                List<JingfeiZhuanjiaMonth> mm恢复List = addzhuanjiamonth(mm入选年份+"-01-01",picijieshuyue,mm新专家月份,100,600);
                输出专家月.addAll(mm恢复List);
                增加或恢复专家id.add(mm专家id);
                if(停发专家id.contains(mm专家id)){ // 在补发之前是停发  防止第三次变动无法判断之前的状态 只保留最新的变动状态
                    停发专家id.removeIf(s -> s.equals(mm专家id));
                }
            } else if (mm变动类型.equals("8")) { // 转隶
                // 转隶的专家 如果存在其他情况 // 还没完成转隶 则新的专家不存在
                if(停发专家id.contains(mm专家id)){ // 之前是停发 则本次不发钱

                }else if(增加或恢复专家id.contains(mm专家id)||转隶专家id.contains(mm专家id)){ // 之前是补发则转隶后的旧专家月份的钱也发了 需要删除
                    for (int j = 0; j < 输出专家月.size(); j++) {
                        JingfeiZhuanjiaMonth mmOne = 输出专家月.get(j);
                        String 专家id = mmOne.getZhuanjiaid();
                        if (专家id.equals(mm专家id)) {
                            String mm当前记录的月份 = zm.format(mmOne.getNianyue());
                            if (mm变动时间.compareTo(mm当前记录的月份) < 0) { // 如果变动月份在这条记录的月份的前边  则删除
                                输出专家月.remove(j);
                                j = j - 1;
                            }
                        }
                    }
                    // 创建转移到新单位的经费月
                    for (int a = 0; a < mm包含月份.size(); a++) {
                        Date mm当前月份 = mm包含月份.get(a).getNianyue();
                        String mm本月份 = zm.format(mm当前月份);
                        String mm截止月份 = mm变动时间;
                        JingfeiZhuanjiaMonth mm新专家月份 = new JingfeiZhuanjiaMonth();
                        mm新专家月份.setId(UUID.randomUUID().toString());
                        mm新专家月份.setJingfeipiciid(mmPiciid);
                        mm新专家月份.setJingfeipiciname(piciName);
                        mm新专家月份.setName(mm姓名);
                        mm新专家月份.setNianyue(mm当前月份);
                        mm新专家月份.setFafangjine(mm经费);
                        mm新专家月份.setBufajine((long) 0);
                        mm新专家月份.setIsbufa((long) 0);
                        mm新专家月份.setIstingfa((long) 0);
                        mm新专家月份.setZjzxpiciid(mmPiciid);

                        if (mm本月份.compareTo(mm截止月份) <= 0) { // 如果本月份在变动月份前边或相等  则发钱 之后新的单位发
                            mm新专家月份.setDeptid(mm单位id);
                            mm新专家月份.setZhuanjiaid(mm专家id);
                            mm新专家月份.setBeizhu1("@"+mm单位id+"@"+"@"+mm单位id2+"@"+"@"+mm单位id3+"@");
                        }else {
                            mm新专家月份.setDeptid(mm新单位id);
                            mm新专家月份.setZhuanjiaid(mm新专家id);
                            mm新专家月份.setBeizhu1("@"+mm新单位id+"@"+"@"+mm单位id4+"@"+"@"+mm单位id5+"@");
                            输出专家月.add(mm新专家月份);
                        }

                    }

                }else{ // 无特殊情况
                    for (int a = 0; a < mm包含月份.size(); a++) {
                        Date mm当前月份 = mm包含月份.get(a).getNianyue();
                        String mm本月份 = zm.format(mm当前月份);
                        String mm截止月份 = mm变动时间;
                        JingfeiZhuanjiaMonth mm新专家月份 = new JingfeiZhuanjiaMonth();
                        mm新专家月份.setId(UUID.randomUUID().toString());
                        mm新专家月份.setJingfeipiciid(mmPiciid);
                        mm新专家月份.setJingfeipiciname(piciName);
                        mm新专家月份.setName(mm姓名);
                        mm新专家月份.setNianyue(mm当前月份);
                        mm新专家月份.setFafangjine(mm经费);
                        mm新专家月份.setBufajine((long) 0);
                        mm新专家月份.setIsbufa((long) 0);
                        mm新专家月份.setIstingfa((long) 0);
                        mm新专家月份.setZjzxpiciid(mmPiciid);

                        if (mm本月份.compareTo(mm截止月份) <= 0) { // 如果本月份在变动月份前边或相等  则发钱 之后新的单位发
                            mm新专家月份.setDeptid(mm单位id);
                            mm新专家月份.setZhuanjiaid(mm专家id);
                            mm新专家月份.setBeizhu1("@"+mm单位id+"@"+"@"+mm单位id2+"@"+"@"+mm单位id3+"@");
                        }else {
                            mm新专家月份.setDeptid(mm新单位id);
                            mm新专家月份.setZhuanjiaid(mm新专家id);
                            mm新专家月份.setBeizhu1("@"+mm新单位id+"@"+"@"+mm单位id4+"@"+"@"+mm单位id5+"@");
                        }
                        输出专家月.add(mm新专家月份);

                    }
                }
                转隶专家id.add(mm新专家id);

            }
        }
        // 超期目前只考虑变为不正常的 不考虑正常的
        for (int i = 0; i < mm超期变动专家List.size(); i++) {
            Map<String, Object> 变动专家One = mm超期变动专家List.get(i);
            String mm专家id = 变动专家One.get("zhuanjiaid") == null ? "" : 变动专家One.get("zhuanjiaid").toString();
            String mm姓名 = 变动专家One.get("xingming") == null ? "" : 变动专家One.get("xingming").toString();
            String mm单位id = 变动专家One.get("deptid") == null ? "" : 变动专家One.get("deptid").toString();
            String mm单位id2 = 变动专家One.get("deptid2") == null ? "" : 变动专家One.get("deptid2").toString();
            String mm单位id3 = 变动专家One.get("deptid3") == null ? "" : 变动专家One.get("deptid3").toString();
            String mm变动时间 = 变动专家One.get("biandongshijian") == null ? "" : 变动专家One.get("biandongshijian").toString();
            SimpleDateFormat zm = new SimpleDateFormat("yyyy-MM");
            if (!已经执行过的专家id.contains(mm专家id)) { // 如果之前停发过就不需要处理 之后之前不是停发的才判断
                for (int a = 0; a < mm包含月份.size(); a++) {
                    Date mm当前月份 = mm包含月份.get(a).getNianyue();
                    String mm本月份 = zm.format(mm当前月份);
                    String mm截止月份 = mm变动时间;
                    if (mm本月份.compareTo(mm截止月份) <= 0) { // 如果本月份在变动月份前边或相等  则发钱
                        JingfeiZhuanjiaMonth mm新专家月份 = new JingfeiZhuanjiaMonth();
                        mm新专家月份.setId(UUID.randomUUID().toString());
                        mm新专家月份.setJingfeipiciid(mmPiciid);
                        mm新专家月份.setJingfeipiciname(piciName);
                        mm新专家月份.setDeptid(mm单位id);
                        mm新专家月份.setZhuanjiaid(mm专家id);
                        mm新专家月份.setName(mm姓名);
                        mm新专家月份.setNianyue(mm当前月份);
                        mm新专家月份.setFafangjine(mm经费);
                        mm新专家月份.setBufajine((long) 0);
                        mm新专家月份.setIsbufa((long) 0);
                        mm新专家月份.setIstingfa((long) 0);
                        mm新专家月份.setZjzxpiciid(mmPiciid);
                        mm新专家月份.setBeizhu1("@"+mm单位id+"@"+"@"+mm单位id2+"@"+"@"+mm单位id3+"@");
                        输出专家月.add(mm新专家月份);
                    }
                }
            }
        }

        return 输出专家月;
    }

    // 循环添加月份
    public List<JingfeiZhuanjiaMonth> addzhuanjiamonth (String mm开始时间,String  结束时间,JingfeiZhuanjiaMonth  mm新专家月份,long oldMoney,long newMoney) {
        List<JingfeiZhuanjiaMonth> mmList = new ArrayList<>();
        try {
            List<Date> mm时间集合 = findYuefenlist(mm开始时间.substring(0,7), 结束时间.substring(0,7));
            Date 开始 = new SimpleDateFormat("yyyy-MM").parse("2001-01");
            for (int i = 0; i < mm时间集合.size(); i++) {
                JingfeiZhuanjiaMonth  mm专家月份 = new JingfeiZhuanjiaMonth();
                mm专家月份.setJingfeipiciid(mm新专家月份.getJingfeipiciid());
                mm专家月份.setJingfeipiciname(mm新专家月份.getJingfeipiciname());
                mm专家月份.setDeptid(mm新专家月份.getDeptid());
                mm专家月份.setZhuanjiaid(mm新专家月份.getZhuanjiaid());
                mm专家月份.setName(mm新专家月份.getName());
                mm专家月份.setZjzxpiciid(mm新专家月份.getZjzxpiciid());
                mm专家月份.setBeizhu1(mm新专家月份.getBeizhu1());
                mm专家月份.setId(UUID.randomUUID().toString());
                mm专家月份.setNianyue(mm时间集合.get(i));
                if (mm时间集合.get(i).getTime() < 开始.getTime()) {
                    mm专家月份.setFafangjine(oldMoney);
                    mm专家月份.setBufajine(oldMoney);
                    mm专家月份.setIsbufa((long) 1);
                    mm专家月份.setIstingfa((long) 0);
                } else {
                    mm专家月份.setFafangjine(newMoney);
                    mm专家月份.setBufajine(newMoney);
                    mm专家月份.setIsbufa((long) 1);
                    mm专家月份.setIstingfa((long) 0);
                }
                mmList.add(mm专家月份);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return mmList;
    }

    // 开始到结束之间的所有月份
    public List<Date> findYuefenlist (String mm开始时间,String  结束时间) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
        // 声明保存日期集合
        List<Date> list = new ArrayList<>();
        try {
            // 转化成日期类型
            Date startDate = sdf.parse(mm开始时间);
            Date endDate = sdf.parse(结束时间);

            //用Calendar 进行日期比较判断
            Calendar calendar = Calendar.getInstance();
            list.add(startDate);

            // 月份加一之后存值
            while (startDate.getTime() < endDate.getTime()) {

                // 设置日期
                calendar.setTime(startDate);

                //把月数增加 1
                calendar.add(Calendar.MONTH, 1);

                // 获取增加后的日期
                startDate = calendar.getTime();
                // 把日期添加到集合
                list.add(startDate);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;

    }
}
